net.onlyValuesCtx.Err (method, view implemented interface methods)

133 uses

	net (current package)
		cgo_unix.go#L76: 		return zero, newDNSError(mapErr(ctx.Err()), lookupName, "")
		dial.go#L735: 			return nil, &OpError{Op: "dial", Net: sd.network, Source: sd.LocalAddr, Addr: ra, Err: mapErr(ctx.Err())}
		fd_unix.go#L53: 			return nil, mapErr(ctx.Err())
		fd_unix.go#L103: 				ret = mapErr(ctx.Err())
		fd_unix.go#L122: 				return nil, mapErr(ctx.Err())
		lookup.go#L358: 		err := newDNSError(mapErr(ctx.Err()), host, "")
		net.go#L817: 		return ctx.Err()

	net/http
		h2_bundle.go#L1031: 	return call.ctx.Err() != nil
		h2_bundle.go#L7920: 					err = req.Context().Err()
		h2_bundle.go#L8504: 		return ctx.Err()
		h2_bundle.go#L8631: 			return ctx.Err()
		h2_bundle.go#L8704: 			err := ctx.Err()
		h2_bundle.go#L8753: 			return ctx.Err()
		h2_bundle.go#L8765: 		return ctx.Err()
		h2_bundle.go#L8822: 				err = ctx.Err()
		h2_bundle.go#L8868: 			return ctx.Err()
		h2_bundle.go#L8887: 		return ctx.Err()
		h2_bundle.go#L9303: 			return 0, ctx.Err()
		h2_bundle.go#L10312: 		return ctx.Err()
		server.go#L3181: 			return ctx.Err()
		server.go#L3856: 		switch err := ctx.Err(); err {
		socks_bundle.go#L49: 				errCh <- ctx.Err()
		transport.go#L1914: 			return nil, connectCtx.Err()
		transport.go#L2809: 		return ctx.Err()

	context
		context.go#L115: 	Err() error
		context.go#L289: 	err := c.Err()
		context.go#L486: 		child.cancel(false, parent.Err(), Cause(parent))
		context.go#L511: 			child.cancel(false, parent.Err(), Cause(parent))
		context.go#L525: 			child.cancel(false, parent.Err(), Cause(parent))

	crypto/tls
		conn.go#L1544: 				ret = ctx.Err()
		quic.go#L520: 	if c.quic.ctx.Err() != nil {

	github.com/cenkalti/backoff/v4
		retry.go#L99: 			if cerr := ctx.Err(); cerr != nil {
		retry.go#L114: 			return res, ctx.Err()

	github.com/coder/websocket
		conn.go#L255: 		return fmt.Errorf("failed to wait for pong: %w", ctx.Err())
		conn.go#L291: 		return fmt.Errorf("failed to acquire lock: %w", ctx.Err())
		read.go#L255: 	if *err != nil && ctx.Err() != nil {
		read.go#L256: 		*err = ctx.Err()
		write.go#L300: 			if ctx.Err() != nil {
		write.go#L301: 				err = ctx.Err()

	github.com/gotd/td/mtproto
		ack.go#L48: 			return errors.Wrap(ctx.Err(), "acl")
		bind.go#L47: 					return ctx.Err()
		conn.go#L316: 					return ctx.Err()
		http_wait.go#L50: 	if err := ctx.Err(); err != nil {
		pfs.go#L23: 		return ctx.Err()
		pfs.go#L47: 			return ctx.Err()
		ping.go#L37: 		return ctx.Err()
		ping.go#L81: 		return ctx.Err()
		ping.go#L137: 			return errors.Wrap(ctx.Err(), "ping loop")
		read.go#L158: 		return ctx.Err()
		read.go#L253: 				return ctx.Err()
		read.go#L271: 				return errors.Wrap(ctx.Err(), "read loop")
		salt.go#L61: 		return ctx.Err()
		salt.go#L73: 			return ctx.Err()
		write.go#L46: 	if err := ctx.Err(); err != nil {

	github.com/gotd/td/pool
		pool.go#L186: 			return nil, ctx.Err()
		pool.go#L188: 			return nil, errors.Wrap(c.ctx.Err(), "DC closed")
		pool.go#L223: 		err = ctx.Err()
		pool.go#L225: 		err = errors.Wrap(c.ctx.Err(), "DC closed")
		pool.go#L258: 		if err != nil && errRetryableOnNewConn(err) && ctx.Err() == nil {

	github.com/gotd/td/rpc
		engine.go#L155: 	case err != nil && !errors.Is(err, retryCtx.Err()):
		engine.go#L169: 		logger.Debug(ctx, "Context done before result", log.Bool("sent", sent), log.Error(ctx.Err()))
		engine.go#L171: 			return ctx.Err()
		engine.go#L186: 			return ctx.Err()
		engine.go#L190: 		return ctx.Err()
		engine.go#L203: 		return errors.Wrap(e.reqCtx.Err(), "engine forcibly closed")
		engine.go#L238: 				return ctx.Err()

	github.com/gotd/td/telegram
		account_status.go#L257: 	if runCtx == nil || runCtx.Err() != nil {
		account_status.go#L268: 		if ctx.Err() == nil {
		auth_lost.go#L94: 		return ctx.Err()
		auth_lost.go#L229: 	if c.ctx != nil && c.ctx.Err() != nil {
		bot.go#L14: 	return ctx.Err()
		builder.go#L129: 					return ctx.Err()
		cdn.go#L175: 		return fetchedCDNKeys{}, ctx.Err()
		cdn.go#L271: 		if err := ctx.Err(); err != nil {
		connect.go#L46: 				return ctx.Err()
		connect.go#L97: 			return ctx.Err()
		connect.go#L239: 			return errors.Wrap(c.ctx.Err(), "client already closed")
		connect.go#L304: 			return ctx.Err()
		connect.go#L306: 			if ctx.Err() != nil {
		connect.go#L313: 				return ctx.Err()
		connect.go#L322: 			return ctx.Err()
		connect.go#L324: 			return c.ctx.Err()
		connect.go#L330: 			return ctx.Err()
		invoke.go#L139: 		timedOut := err != nil && ctx.Err() == nil && errors.Is(context.Cause(reqCtx), errNoResponse)
		invoke.go#L185: 			return errors.Wrap(ctx.Err(), "wait for reconnect")
		invoke.go#L188: 			return errors.Wrap(c.ctx.Err(), "client closed")
		invoke.go#L219: 		return ctx.Err()
		lifecycle.go#L137: 	if err := ctx.Err(); err != nil {
		lifecycle.go#L168: 		if lifeErr := o.lifetime.Err(); lifeErr != nil && errors.Is(err, lifeErr) {
		lifecycle.go#L199: 			switch lifeErr := o.lifetime.Err(); {
		lifecycle.go#L222: 		err := errors.Wrap(ctx.Err(), "start")
		lifecycle.go#L293: 		return errors.Wrap(ctx.Err(), "shutdown")
		lifecycle.go#L345: 		return errors.Wrap(ctx.Err(), "wait")
		metrics.go#L187: 	if ctx.Err() != nil || errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
		migrate_to_dc.go#L23: 		return ctx.Err()
		migrate_to_dc.go#L32: 		return ctx.Err()
		migrate_to_dc.go#L44: 		return ctx.Err()
		migrate_to_dc.go#L84: 		return ctx.Err()
		pool.go#L29: 		return nil, errors.Wrap(c.ctx.Err(), "client already closed")
		sub_conns.go#L153: 		return nil, ctx.Err()
		sub_conns.go#L173: 	if err != nil && clientCtx.Err() != nil {
		sub_conns.go#L174: 		err = errors.Wrap(clientCtx.Err(), "client closed")
		sub_conns.go#L180: 		if clientCtx.Err() != nil {
		sub_conns.go#L182: 			err = errors.Wrap(clientCtx.Err(), "client closed")
		sub_conns.go#L198: 	canceled := err != nil && clientCtx.Err() != nil

	github.com/gotd/td/telegram/auth/qrlogin
		qrlogin.go#L333: 			return nil, errors.Wrap(ctx.Err(), "wait for login")
		qrlogin.go#L346: 			if ctxErr := ctx.Err(); ctxErr != nil {

	github.com/gotd/td/telegram/dcs
		http.go#L131: 		return ctx.Err()
		http.go#L239: 		if c.ctx.Err() != nil {
		plain.go#L191: 			return nil, ctx.Err()

	github.com/gotd/td/telegram/downloader
		cdn_state_machine.go#L148: 		if err := ctx.Err(); err != nil {
		cdn_state_machine.go#L312: 		if err := ctx.Err(); err != nil {
		cdn_verify.go#L148: 		if err := ctx.Err(); err != nil {
		metrics.go#L188: 	case ctx.Err() != nil:
		metrics.go#L221: 		if ctx.Err() != nil {
		parallel.go#L52: 						return ctx.Err()
		parallel.go#L72: 						return ctx.Err()
		retry.go#L40: 	if ctx.Err() != nil {
		retry.go#L61: 		if err := ctx.Err(); err != nil {
		retry.go#L74: 				if ctxErr := ctx.Err(); ctxErr != nil {
		scheduler.go#L126: 			return 0, ctx.Err()
		sink.go#L29: 				return ctx.Err()
		sink.go#L50: 				return ctx.Err()
		stream.go#L39: 				return ctx.Err()

	github.com/gotd/td/telegram/internal/manager
		conn.go#L174: 		if err != nil && ctx.Err() == nil {
		conn.go#L216: 			log.Error(ctx.Err()),
		conn.go#L218: 		return ctx.Err()

	github.com/gotd/td/tgerr
		flood_wait.go#L72: 			return false, ctx.Err()

	github.com/refraction-networking/utls
		conn.go#L1558: 				interruptRes <- handshakeCtx.Err()
		u_conn.go#L354: 				interruptRes <- handshakeCtx.Err()

	golang.org/x/net/internal/socks
		client.go#L43: 				errCh <- ctx.Err()

	golang.org/x/net/proxy
		dial.go#L44: 		if conn != nil && ctx.Err() != nil {
		dial.go#L50: 		err = ctx.Err()